from abc import ABC, abstractmethod


class RDFDatatype(ABC):
    '''
     * Return the URI which is the label for this datatype
    '''

    # return String
    def getURI(self):
        pass

    '''
     * Convert a value of this datatype out
     * to lexical form.
    '''

    # param Object
    # return String
    def unparse(self, value):
        pass

    '''
     * Parse a lexical form of this datatype to a value
     *
     * @throws DatatypeFormatException if the lexical form is not legal
    '''

    # param String
    # return Object
    # throws DatatypeFormatException
    def parse(self, lexicalForm):
        pass

    '''
     * Test whether the given string is a legal lexical form
     * of this datatype.
    '''

    # param String
    # return boolean
    def isValid(self, lexicalForm):
        pass

    '''
     * Test whether the given object is a legal value form
     * of this datatype.
    '''

    # param Object
    # return boolean
    def isValidValue(self, valueForm):
        pass

    '''
     * Test whether the given LiteralLabel is a valid instance
     * of this datatype. This takes into account typing information
     * as well as lexical form - for example an xsd:string is
     * never considered valid as an xsd:integer (even if it is
     * lexically legal like "1").
    '''

    # param LiteralLabel
    # return boolean
    def isValidLiteral(self, lit):
        pass

    '''
     * Compares two instances of values of the given datatype.
     * This defaults to just testing equality of the java value
     * representation but datatypes can override this. We pass the
     * entire LiteralLabel to allow the equality function to take
     * the xml:lang tag and the datatype itself into account.
    '''

    # param LiteralLabel LiteralLabel
    # return boolean
    def isEqual(self, value1, value2):
        pass

    '''
     * Gets the hash code of a given value. This defaults to
     * lit.getValue().hashCode(), but datatypes can override this, and array types
     * must.
    '''

    # param LiteralLabel
    # return int
    def getHashCode(self, lit):
        pass

    '''
     * If this datatype is used as the canonical representation
     * for a particular java datatype then return that java type,
     * otherwise returns null.
    '''

    # return Class<?>
    def getJavaClass(self):
        pass

    '''
     * Cannonicalise a java Object value to a normal form.
     * Primarily used in cases such as xsd:integer to reduce
     * the Java object representation to the narrowest of the Number
     * subclasses to ensure that indexing of typed literals works.
    '''

    # param object
    # return Object
    def cannonicalise(self, value):
        pass

    '''
     * Returns an object giving more details on the datatype.
     * This is type system dependent. In the case of XSD types
     * this will be an instance of
     * <code>org.apache.xerces.impl.xs.dv.XSSimpleType</code>.
    '''

    # return Object
    def extendedTypeDefinition(self):
        pass

    '''
     * Normalization. If the value is narrower than the current data type
     * (e.g. value is xsd:date but the time is xsd:datetime) returns
     * the narrower type for the literal.
     * If the type is narrower than the value then it may normalize
     * the value (e.g. set the mask of an XSDDateTime)
     * Currently only used to narrow gener XSDDateTime objects
     * to the minimal XSD date/time type.
     *
     * @param value the current object value
     * @param dt    the currently set data type
     * @return a narrower version of the datatype based on the actual value range
    '''

    # return RDFDatatype
    def normalizeSubType(self, value, dt):
        pass
